Party Bot

Work Distribution

Code Appendix

// pg.py
import pygame
import os
import RPi.GPIO as GPIO
import random
import time

os.putenv('SDL_VIDEODRIVER', 'fbcon')  # Display on piTFT
os.putenv('SDL_FBDEV', '/dev/fb0')
os.putenv('SDL_MOUSEDRV', 'TSLIB')     # Track mouse clicks on piTFT
os.putenv('SDL_MOUSEDEV', '/dev/input/touchscreen') 

#pygame initialization

pygame.init()
size = width, height = 320, 240

#defining colors we are using in pygame in RGB
black = 0, 0, 0
white = 255, 255, 255
dark_grey = 90, 90, 90

#Intializae GPIO pins
GPIO.setmode(GPIO.BCM) 
GPIO.setup(27, GPIO.IN) #Initialize pin for break button
GPIO.add_event_detect(27, GPIO.RISING)

screen = pygame.display.set_mode(size)
screen.fill(white)
pygame.display.flip()


# List of track names we are going to use
tracks = ['Cupid', 'OMG', 'Ditto', 'Hotel Room Service', 'Lovesick Girls',
          'Love Story', 'Blinding Lights', 'Umbrella', 'Levitating', 'Pepas',
          'Dancing Queen', 'Mr. Brightside', 'Glimpse of Us', 'Die For You',
          'La La Lost You', 'Oceans & Engines']

# Data collected from Music class using spotify api put into json format for easy scaling
song_dict = {
    'Cupid': {
        'name': 'Cupid',
        'artist': 'FIFTY FIFTY',
        'genre': ['k-pop girl group'],
        'image': 'Cupids.jpg'
    },
    'OMG': {
        'name': 'OMG',
        'artist': 'NewJeans',
        'genre': ['k-pop', 'k-pop girl group'],
        'image': 'OMG.jpg'
    },
    'Ditto': {
        'name': 'Ditto',
        'artist': 'NewJeans',
        'genre': ['k-pop', 'k-pop girl group'],
        'image': 'Ditto.jpg'
    },
    'HotelRoomService': {
        'name': 'Hotel Room Service',
        'artist': 'Pitbull',
        'genre': ['dance pop', 'miami hip hop', 'pop'],
        'image': 'HotelRoomService.jpg'
    },
    'LovesickGirls': {
        'name': 'Lovesick Girls',
        'artist': 'BLACKPINK',
        'genre': ['k-pop', 'k-pop girl group', 'pop'],
        'image': 'LovesickGirls.jpg'
    },
    'LoveStory': {
        'name': 'Love Story',
        'artist': 'Taylor Swift',
        'genre': ['pop'],
        'image': 'LoveStory.jpg'
    },
    'BlindingLights': {
        'name': 'Blinding Lights',
        'artist': 'The Weeknd',
        'genre': ['canadian contemporary r&b', 'canadian pop', 'pop'],
        'image': 'BlindingLights.jpg'
    },
    'Umbrella': {
        'name': 'Umbrella',
        'artist': 'Rihanna',
        'genre': ['barbadian pop', 'pop', 'urban contemporary'],
        'image': 'Umbrella.jpg'
    },
    'Levitating': {
        'name': 'Levitating',
        'artist': 'Dua Lipa',
        'genre': ['dance pop', 'pop', 'uk pop'],
        'image': 'Levitating.jpg'
    },
    'Pepas': {
        'name': 'Pepas',
        'artist': 'Farruko',
        'genre': ['reggaeton', 'trap latino', 'urbano latino'],
        'image': 'Pepas.jpg'
    },
    'DancingQueen': {
        'name': 'Dancing Queen',
        'artist': 'ABBA',
        'genre': ['europop', 'swedish pop'],
        'image': 'DancingQueen.jpg'
    },
    'MrBrightside': {
        'name': 'Mr. Brightside',
        'artist': 'The Killers',
        'genre': ['alternative rock', 'dance rock', 'modern rock', 'permanent wave', 'rock'],
        'image': 'MrBrightside.jpg'
    },
    'GlimpseofUs': {
        'name': 'Glimpse of Us',
        'artist': 'Joji',
        'genre': ['viral pop'],
        'image': 'GlimpseofUs.jpg'
    },
    'DieForYou': {
        'name': 'Die For You',
        'artist': 'The Weeknd',
        'genre': ['canadian contemporary r&b', 'canadian pop', 'pop'],
        'image': 'DieForYou.jpg'
    },
    'LaLaLostYou': {
        'name': 'La La Lost You',
        'artist': '88rising',
        'genre': ['asian american hip hop'],
        'image': 'LaLaLostYou.jpg'
    },
    'OceansEngines': {
        'name': 'Oceans & Engines',
        'artist': 'NIKI',
        'genre': ['indonesian r&b'],
        'image': 'OceansEngine.jpg'
    }
}


def transform(nested_list):
    regular_list = []
    for ele in nested_list:
        if type(ele) is list:
            regular_list.append(ele)
        else:
            regular_list.append([ele])
    return regular_list

# Defining genre lookup
genres = []
song_values = song_dict.items()
for key, value in song_values:
    genres.append(value['genre'])
    
flatlist = [element for sublist in genres for element in sublist]

unique_genre_list = list(set(flatlist))

# Handling helper for when the screen is pressed

def press_handling():
    for event in pygame.event.get():
        if event.type == pygame.MOUSEBUTTONDOWN:
            pos = event.pos
            button_down(pos)
        elif event.type == SONG_END:
            stop()
            screen_state = 0
            display_screen(0)
            started_playing = False

# A customized sleep function that periodically check for user inputs 

def custom_sleep(t):
    loops = t * 10
    for i in range(loops):
        if not song_playing:
            break
        press_handling()
        if not song_playing:
            break
        time.sleep(0.1)


# Pin intialization for the motors
# F and B represent the front motorcontroller and back motorcontroller respectively

F_PWMA = 12 
F_PWMB = 4
F_AI1 = 21  
F_AI2 = 23

F_BI1 = 19 
F_BI2 = 17

B_PWMA = 26 
B_PWMB = 22

B_AI1 = 16
B_AI2 = 20

B_BI1 = 6
B_BI2 = 5


# Initializing the pins
GPIO.setup(F_PWMA, GPIO.OUT)
GPIO.setup(F_PWMB, GPIO.OUT)
GPIO.setup(F_AI1, GPIO.OUT)
GPIO.setup(F_AI2, GPIO.OUT)
GPIO.setup(F_BI1, GPIO.OUT)
GPIO.setup(F_BI2, GPIO.OUT)

GPIO.setup(B_PWMA, GPIO.OUT)
GPIO.setup(B_PWMB, GPIO.OUT)
GPIO.setup(B_AI1, GPIO.OUT)
GPIO.setup(B_AI2, GPIO.OUT)
GPIO.setup(B_BI1, GPIO.OUT)
GPIO.setup(B_BI2, GPIO.OUT)

# Initializing the PWM signals for the motors
pf1 = GPIO.PWM(F_PWMA, 50)
pf2 = GPIO.PWM(F_PWMB, 50)

pb1 = GPIO.PWM(B_PWMA, 50)
pb2 = GPIO.PWM(B_PWMB, 50)

# Defining different speeds for the motor
full = 100.0
fast = 75.0
half = 50.0
slow = 35.0

# Defining the direction for the motor
forward = True
back = False

# Stop helper function for front motor 1
def stop_f1():
    pf1.stop()
    GPIO.output(F_AI1, GPIO.LOW)
    GPIO.output(F_AI2, GPIO.LOW)

# Run helper function for front motor 1 with speed given as argument
def run_f1(speed, direction):
    stop_f1()
    if direction:
        GPIO.output(F_AI1, GPIO.HIGH)
    else:
        GPIO.output(F_AI2, GPIO.HIGH)
    pf1.start(speed)

def stop_f2():
    pf2.stop()
    GPIO.output(F_BI1, GPIO.LOW)
    GPIO.output(F_BI2, GPIO.LOW)

def run_f2(speed, direction):
    stop_f2()
    if direction:
        GPIO.output(F_BI1, GPIO.HIGH)
    else:
        GPIO.output(F_BI2, GPIO.HIGH)
    pf2.start(speed)

def stop_b1():
    pb1.stop()
    GPIO.output(B_AI1, GPIO.LOW)
    GPIO.output(B_AI2, GPIO.LOW)

def run_b1(speed, direction):
    stop_b1()
    if direction:
        GPIO.output(B_AI1, GPIO.HIGH)
    else:
        GPIO.output(B_AI2, GPIO.HIGH)
    pb1.start(speed)

def stop_b2():
    pb2.stop()
    GPIO.output(B_BI1, GPIO.LOW)
    GPIO.output(B_BI2, GPIO.LOW)

def run_b2(speed, direction):
    stop_b2()
    if direction:
        GPIO.output(B_BI1, GPIO.HIGH)
    else:
        GPIO.output(B_BI2, GPIO.HIGH)
    pb2.start(speed)


# Helper function to stop all motors
def stop():
    stop_f1()
    stop_f2()
    stop_b1()
    stop_b2()
    return

# Helper function to set all motors forward
def forward(speed): 
    global forward
    run_f1(speed, forward)
    run_f2(speed, forward)
    run_b1(speed, forward)
    run_b2(speed, forward)
    return

# Helper function to set all motors backwards
def backward(speed):
    global back
    run_f1(speed, back)
    run_f2(speed, back)
    run_b1(speed, back)
    run_b2(speed, back)
    return

def turn_left(speed):
    global forward, back
    run_f1(speed, forward)
    run_f2(speed, back)
    run_b1(speed, forward)
    run_b2(speed, back)
    return

def turn_right(speed):
    global forward, back
    run_f1(speed, back)
    run_f2(speed, forward)
    run_b1(speed, back)
    run_b2(speed, forward)
    return

# Helper to make the robot slide sideways towards the right
def set_right(speed):
    global forward, back
    run_f1(speed, forward)
    run_f2(speed, back)
    run_b1(speed, back)
    run_b2(speed, forward)
    return

def set_left(speed):
    global forward, back
    run_f1(speed, back)
    run_f2(speed, forward)
    run_b1(speed, forward)
    run_b2(speed, back)
    return

# A subsequence of movement consisting of the robot moving forward then turning
def forward_twist(speed):
    forward(speed)
    custom_sleep(1)
    turn_right(speed)
    custom_sleep(1)
    turn_left(speed)
    custom_sleep(1)
    return

# A subsequence of movement consisting of the robot moving backwards then turning
def back_twist(speed):
    backward(speed)
    custom_sleep(1)
    turn_left(speed)
    custom_sleep(1)
    turn_right(speed)
    custom_sleep(1)
    return

# A subsequence of movement consisting of the robot turning right for a specific interval
def spin_right(speed):
    turn_right(speed)
    custom_sleep(3)
    return 

# A subsequence of movement consisting of the robot turning left for a specific interval
def spin_left(speed):
    turn_left(speed)
    custom_sleep(3)
    return

# A subsequence of movement consisting of the robot moving forward then backwards
def for_back(speed):
    forward(speed)
    custom_sleep(3)
    stop()
    custom_sleep(3)
    backward(speed)
    custom_sleep(3)
    return

def left_right_step(speed):
    set_left(speed)
    custom_sleep(3)
    set_right(speed)
    custom_sleep(3)
    return

def right_left_step(speed):
    set_right(speed)
    custom_sleep(3)
    set_left(speed)
    custom_sleep(3)
    return

def left_for_right(speed):
    set_left(speed)
    custom_sleep(3)
    forward(speed)
    custom_sleep(3)
    set_right(speed)
    custom_sleep(3)
    backward(speed)
    return

# Variable indicating if a song is currently playing, the robot only moves if this variable is True
song_playing = False

# Function determining the movement for songs in all rock genre
def rock_movement():
    global full, fast, half, slow, song_playing
    chance = random.uniform(0, 1) # Utilize random number generator to randomize the possible movements robot can take
    if chance < 0.2:
        forward_twist(slow)
    elif chance < 0.5:
        spin_right(slow)
    elif chance > 0.8:
        spin_left(slow)
    else:
        for_back(slow)
    if song_playing: # If song is still playing, loop back to the movement again
        rock_movement()
    else:
        stop()
    
# Function determining the movement for songs in all pop genre
def pop_movement():
    global full, fast, half, slow, song_playing
    chance = random.uniform(0, 1)
    if chance < 0.2:
        left_right_step(full)
    elif chance < 0.4:
        forward_twist(full)
    elif chance < 0.6:
        spin_right(full)
    elif chance < 0.5:
        spin_left(full)
    else:
        for_back(full)
    if song_playing:
        pop_movement()
    else:
        stop()
    

def kpop_movement():
    global full, fast, half, slow, song_playing
    chance = random.uniform(0, 1)
    if chance < .15:
        left_right_step(full)
    elif chance < .3:
        right_left_step(full)
    elif chance < .45:
        forward_twist(full)
    elif chance < .6:
        for_back(full)
    else:
        left_for_right(full)
    if song_playing:
        kpop_movement()
    else:
        stop()
    

def rb_movement():
    global full, fast, half, slow, song_playing
    chance = random.uniform(0, 1)
    if chance < .2:
        spin_right(slow)
    elif chance < .4:
        spin_left(slow)
    elif chance < .6:
        forward_twist(slow)
    elif chance < .8:
        for_back(slow)
    else:
        left_right_step(slow)
    if song_playing:
        rb_movement()
    else:
        stop()
    

def hiphop_movement():
    global full, fast, half, slow, song_playing
    chance = random.uniform(0, 1)
    if chance < 0.2:
        forward_twist(full)
    elif chance < 0.5:
        spin_right(full)
    elif chance > 0.8:
        spin_left(full)
    else:
        for_back(full)
    if song_playing:
        hiphop_movement()
    else:
        stop()
   

def lat_movement():
    global full, fast, half, slow, song_playing
    chance = random.uniform(0, 1)
    if chance < 0.2:
        forward_twist(full)
    elif chance < 0.5:
        spin_right(full)
    elif chance > 0.8:
        spin_left(full)
    else:
        for_back(full)
    if song_playing:
        lat_movement()
    else:
        stop()
    


cur_gen = None # The genre for the current song in play

# Helper function to identify which genre each subgroup of genre belon to and call the movement
def findPace(genre):
    if genre in ["dance rock", "modern rock", "rock", "alternative rock"]:
        rock_movement()
    elif genre in ["dance pop", "uk pop", "europop", "pop", "swedish pop", "barbadian pop", "canadian pop", "viral pop"]:
        pop_movement()
    elif genre in ["kpop", "k-pop girl group", "k-pop"]:
        kpop_movement()
    elif genre in ["indonesian r&b", "canadian contemporary r&b"]:
        rb_movement()
    elif genre in ["miami hip hop", "asian american hip hop"]:
        hiphop_movement()
    elif genre in ["urban contemporary",  "trap latino",  "urbano latino", "permanent wave",  "reggaeton"]:
        lat_movement()
    return

# Left and right arrows images for the home screen
left_arr = pygame.image.load("left.png")
right_arr = pygame.image.load("right.png")

left_arr = pygame.transform.scale(left_arr, (60, 20))
right_arr = pygame.transform.scale(right_arr, (60, 20))

left_rect = left_arr.get_rect()
right_rect = right_arr.get_rect()

left_rect.center = (40, 210)
right_rect.center = (280, 210)


def init():
    pygame.init()


# Fill the screen with white background color
def reset_screen():
    screen.fill(white)
    pygame.display.flip()

# display the left and rigth arrow buttons

def left_arrow_button():
    global left_arr, left_rect
    screen.blit(left_arr, left_rect)
    pygame.display.flip()


def right_arrow_button():
    global right_arr, rigth_rect
    screen.blit(right_arr, right_rect)
    pygame.display.flip()


def song_list_title():
    title_txt = pygame.font.Font(None, 24).render(
        "Song List", True, black)
    title_rect = title_txt.get_rect(center=(160, 25))
    screen.blit(title_txt, title_rect)
    pygame.display.flip()


# Array for displaying which 5 songs are displayed on the home screen at all times
song_index = 0
cur_songs = [None] * 5
cur_songs[0] = tracks[0]
cur_songs[1] = tracks[1]
cur_songs[2] = tracks[2]
cur_songs[3] = tracks[3]
cur_songs[4] = tracks[4]

# Moving the array to the next 5 songs on the overall song array
def list_forward(t):
    global song_index
    if t:
        song_index += 5
    else:
        song_index -= 5
    for i in range(5):
        if i + song_index < len(tracks):
            cur_songs[i] = tracks[i + song_index]
        else:
            cur_songs[i] = None


# left arrow is arrows[0] and right arrow is arrows[1]
arrows = [[0, 65, 200, 240], [255, 320, 200, 240]]

# Dispalying the song name on piTFT screen
def hard_code_songs():
    if cur_songs[0]:
        song1_txt = pygame.font.Font(None, 16).render(
            cur_songs[0], True, black)
        song1_rect = song1_txt.get_rect(center=(160, 65))
        screen.blit(song1_txt, song1_rect)
    if cur_songs[1]:
        song2_txt = pygame.font.Font(None, 16).render(
            cur_songs[1], True, black)
        song2_rect = song2_txt.get_rect(center=(160, 95))
        screen.blit(song2_txt, song2_rect)
    if cur_songs[2]:
        song3_txt = pygame.font.Font(None, 16).render(
            cur_songs[2], True, black)
        song3_rect = song3_txt.get_rect(center=(160, 125))
        screen.blit(song3_txt, song3_rect)
    if cur_songs[3]:
        song4_txt = pygame.font.Font(None, 16).render(
            cur_songs[3], True, black)
        song4_rect = song4_txt.get_rect(center=(160, 155))
        screen.blit(song4_txt, song4_rect)
    if cur_songs[4]:
        song5_txt = pygame.font.Font(None, 16).render(
            cur_songs[4], True, black)
        song5_rect = song5_txt.get_rect(center=(160, 185))
        screen.blit(song5_txt, song5_rect)
    pygame.display.flip()



screen_state = 0 # state of screen, song list choosing is 0 and the mp3 displaying a specific sogn is screen state 1
click_song_display = None # the display name of the current in display song
click_song = None # the internal name of the current in display song 
cur_song_index = None # index of the song in the overall song list

# matching the display name of the song to the internal name of the song
name_dt = {"Cupid": "Cupid", "OMG": "OMG", "Ditto": "Ditto", "Hotel Room Service": "HotelRoomService", "Lovesick Girls": "LovesickGirls",
           "Love Story": "LoveStory", "Blinding Lights": "BlindingLights", "Umbrella": "Umbrella", "Levitating": "Levitating", "Pepas":
           "Pepas", "Dancing Queen": "DancingQueen", "Mr. Brightside": "MrBrightside", "Glimpse of Us": "GlimpseofUs", "Die For You":
           "DieForYou", "La La Lost You": "LaLaLostYou", "Oceans & Engines": "OceansEngines"}

def map_name(x):
    global click_song
    click_song = name_dt[x]


def song_options_control():

    quit_txt = pygame.font.Font(None, 16).render("End Program", True, black)
    quit_rect = quit_txt.get_rect(center=(260, 100))
    screen.blit(quit_txt, quit_rect)

# Load and display the album cover, artist name, and song name of the selected song
def display_song_options():
    global click_song_dislay, click_song
    reset_screen()
    img_direct = "/home/pi/Final/images/" + click_song + ".jpg" #
    song_pic = pygame.image.load(img_direct)
    song_pic = pygame.transform.scale(song_pic, (100, 100))
    song_rect = song_pic.get_rect()
    song_rect.center = (80, 80)
    screen.blit(song_pic, song_rect)
    pygame.display.flip()
    name_txt = pygame.font.Font(None, 20).render(
        click_song_display, True, black)
    name_rect = name_txt.get_rect(center=(80, 160))
    screen.blit(name_txt, name_rect)
    singer_txt = pygame.font.Font(None, 20).render(
        song_dict[click_song]["artist"], True, black)
    singer_rect = singer_txt.get_rect(center=(80, 190))
    screen.blit(singer_txt, singer_rect)
    pygame.display.flip()


# Code in pygame for displaying the mp3 feature buttons including fast forward/backwards, and volume up down
# and pausing/playing
def display_song_buttons():
    global song_playing
    if not song_playing:
        play_img = pygame.image.load("/home/pi/Final/buttons/play.png")
    else:
        play_img = pygame.image.load("/home/pi/Final/buttons/pause.jpeg")
    play_img = pygame.transform.scale(play_img, (60, 60))
    play_rect = play_img.get_rect()
    play_rect.center = (240, 90)
    screen.blit(play_img, play_rect)
    forward_img = pygame.image.load("/home/pi/Final/buttons/forward1.png")
    forward_img = pygame.transform.scale(forward_img, (45, 45))
    forward_rect = forward_img.get_rect()
    forward_rect.center = (290, 140)
    screen.blit(forward_img, forward_rect)
    back_img = pygame.image.load("/home/pi/Final/buttons/back1.jpeg")
    back_img = pygame.transform.scale(back_img, (45, 45))
    back_rect = back_img.get_rect()
    back_rect.center = (190, 140)
    screen.blit(back_img, back_rect)
    volume_txt = pygame.font.Font(None, 18).render("Volume", True, black)
    volume_rect = volume_txt.get_rect(center=(240, 210))
    screen.blit(volume_txt, volume_rect)
    plus_img = pygame.image.load("/home/pi/Final/buttons/plus.png")
    plus_img = pygame.transform.scale(plus_img, (30, 30))
    plus_rect = plus_img.get_rect()
    plus_rect.center = (290, 210)
    screen.blit(plus_img, plus_rect)
    minus_img = pygame.image.load("/home/pi/Final/buttons/minus.png")
    minus_img = pygame.transform.scale(minus_img, (30, 30))
    minus_rect = minus_img.get_rect()
    minus_rect.center = (190, 210)
    screen.blit(minus_img, minus_rect)
    return_img = pygame.image.load("/home/pi/Final/buttons/return.png")
    return_img = pygame.transform.scale(return_img, (30, 30))
    return_rect = return_img.get_rect()
    return_rect.center = (295, 30)
    screen.blit(return_img, return_rect)
    pygame.display.flip()

# Helper function to handle what to display on pygame for each corresponding screen states
def display_screen(state):
    global song_index, click_song_display, click_song
    if state == 0:
        reset_screen()
        song_list_title()
        hard_code_songs()
        if song_index != 0:
            left_arrow_button()
        if song_index + 5 < len(tracks):
            right_arrow_button()
    if state == 1:
        display_song_options()
        display_song_buttons()


started_playing = False
SONG_END = pygame.USEREVENT # Setting a pygame user event to notify when a song finished playing

cur_volume = 0.5 # starting volume for the song which is half volume

# load the specific mp3 file into pygame
def music_selected(x):
    pygame.mixer.init()
    pygame.mixer.music.load("/home/pi/Final/mp3/" + x + ".mp3")
    pygame.mixer.music.set_endevent(SONG_END)
    pygame.mixer.music.set_volume(cur_volume)
    #pygame.mixer.music.play()

def pause_song():
    pygame.mixer.music.pause()


def unpause_song():
    pygame.mixer.music.unpause()


def play_song():
    pygame.mixer.music.play()

# Setting up the song playing features for a song when it is loaded in display on the piTFT
def new_song(x):
    global click_song, click_song_display, song_playing, cur_song_index, started_playing
    click_song_display = x
    click_song = name_dt[x]
    song_playing = False
    cur_song_index = tracks.index(x)
    music_selected(click_song)
    started_playing = False

def increase_volume():
    global cur_volume
    if cur_volume < 1.0:
        cur_volume = cur_volume + .1
    pygame.mixer.music.set_volume(cur_volume)

def decrease_volume():
    global cur_volume
    if cur_volume > 0:
        cur_volume = cur_volume - .1
    pygame.mixer.music.set_volume(cur_volume)


# Helper function handler for when a button is pressed and determining the appropriate handling for each button
def button_down(pos):
    global screen_state, song_index, click_song, click_song_display, song_playing, cur_song_index, started_playing, cur_gen
    if screen_state == 0: # Button press handler for button presses during the start screen
        if pos[0] > arrows[0][0] and pos[0] < arrows[0][1]: # for if forward button is pressed
            if pos[1] > arrows[0][2] and pos[1] < arrows[0][3]:
                if song_index != 0:
                    list_forward(False)
                    display_screen(0)
        elif pos[0] > arrows[1][0] and pos[0] < arrows[1][1]:
            if pos[1] > arrows[1][2] and pos[1] < arrows[1][3]:
                if song_index + 5 < len(tracks):
                    list_forward(True)
                    display_screen(0) 
        elif pos[0] > 100 and pos[0] < 220: # handling button presses for each song that is displayed
            if pos[1] > 55 and pos[1] < 75:
                screen_state = 1
                click_song_display = cur_songs[0]
                map_name(cur_songs[0])
                new_song(cur_songs[0])
                display_screen(screen_state)
                cur_gen = song_dict[click_song]["genre"][0]
            elif pos[1] > 85 and pos[1] < 105:
                if cur_songs[1] == None:
                    return
                screen_state = 1
                click_song_display = cur_songs[1]
                map_name(cur_songs[1])
                new_song(cur_songs[1])
                display_screen(screen_state)
                cur_gen = song_dict[click_song]["genre"][0]
            elif pos[1] > 115 and pos[1] < 135:
                if cur_songs[2] == None:
                    return
                screen_state = 1
                click_song_display = cur_songs[2]
                map_name(cur_songs[2])
                new_song(cur_songs[2])
                display_screen(screen_state)
                cur_gen = song_dict[click_song]["genre"][0]
            elif pos[1] > 145 and pos[1] < 165:
                if cur_songs[3] == None:
                    return
                screen_state = 1
                click_song_display = cur_songs[3]
                map_name(cur_songs[3])
                new_song(cur_songs[3])
                display_screen(screen_state)
                cur_gen = song_dict[click_song]["genre"][0]
            elif pos[1] > 175 and pos[1] < 195:
                if cur_songs[4] == None:
                    return
                screen_state = 1
                click_song_display = cur_songs[4]
                map_name(cur_songs[4])
                new_song(cur_songs[4])
                display_screen(screen_state)
                cur_gen = song_dict[click_song]["genre"][0]
    if screen_state == 1: # Button press handler for handling button presses during the song screen
        if (abs(pos[0] - 240) ** 2 + abs(pos[1] - 60) ** 2) ** 0.5 <= 30: # handler for play button being hit
            song_playing = not song_playing
            display_screen(screen_state)
            if song_playing:
                if not started_playing:
                    started_playing = True
                    play_song()
                    findPace(cur_gen)
                else:
                    unpause_song()
                    findPace(cur_gen)
            else:
                pause_song()
                stop()

        # next song and previous song button
        if (abs(pos[0] - 290) ** 2 + abs(pos[1] - 110) ** 2) ** 0.5 <= 30:
            pause_song()
            if cur_song_index != len(tracks) - 1:
                new_song(tracks[cur_song_index + 1])
            display_screen(screen_state)
            cur_gen = song_dict[click_song]["genre"][0]
        if (abs(pos[0] - 190) ** 2 + abs(pos[1] - 110) ** 2) ** 0.5 <= 30:
            pause_song()
            if cur_song_index != 0:
                new_song(tracks[cur_song_index - 1])
            display_screen(screen_state)
            cur_gen = song_dict[click_song]["genre"][0]
        if (abs(pos[0] - 295) ** 2 + abs(pos[1] - 30) ** 2) ** 0.5 <= 20:
            pause_song()
            screen_state = 0
            display_screen(screen_state)
            cur_gen = song_dict[click_song]["genre"][0]
        if (abs(pos[0] - 290) ** 2 + abs(pos[1] - 190) ** 2) ** 0.5 <= 20: # for handling increase and decrease in volume
            increase_volume()
        if (abs(pos[0] - 190) ** 2 + abs(pos[1] - 190) ** 2) ** 0.5 <= 20:
            decrease_volume()
        
# initial display
stop()
left_arrow_button()
right_arrow_button()
song_list_title()
hard_code_songs()

while 1: # main loop 
    if (GPIO.event_detected(27)): # program break button
        break
    
    for event in pygame.event.get(): # constantly polling for button presses 
        if event.type == pygame.MOUSEBUTTONDOWN:
            pos = event.pos
            button_down(pos) 
        elif event.type == SONG_END:
            screen_state = 0
            display_screen(0)
            started_playing = False
              

 
// music.py
import ssl
from spotipy.oauth2 import SpotifyClientCredentials
import spotipy
from spotipy.oauth2 import SpotifyOAuth
from dotenv import load_dotenv
import sys
import random
import requests
from PIL import Image

load_dotenv()

# class for collecting and aggregating Spotify music data
class Music:
    scope = [
        'user-modify-playback-state',
        'user-read-playback-state',
        'user-read-currently-playing',
        'playlist-read-private',
    ]

    sp = spotipy.Spotify(auth_manager=SpotifyClientCredentials())

    @classmethod
    def populate_tracks(cls):
        tracks = []
        track_ids = [
            '5mg3VB3Qh7jcR5kAAC4DSV',
            '65FftemJ1DbbZ45DUfHJXE',
            '3r8RuvgbX9s7ammBn07D3W',
            '6Rb0ptOEjBjPPQUlQtQGbL',
            '4Ws314Ylb27BVsvlZOy30C',
            '1vrd6UOGamcKNGnSHJQlSt',
            '0VjIjW4GlUZAMYd2vXMi3b',
            '49FYlytm3dAAraYgpoJZux',
            '39LLxExYz6ewLAcYrzQQyP',
            '5fwSHlTEWpluwOM0Sxnh5k',
            '0GjEhVFGZW8afUYGChu3Rr',
            '003vvx7Niy0yvhvHt4a68B',
            '6xGruZOHLs39ZbVccQTuPZ',
            '2Ch7LmS7r2Gy2kc64wv3Bz',
            '5Htq8DDDN0Xce9MwqzAzui',
            '3vZk7OAUjMtVDNC852aNqi',
        ]
        for i in range(len(track_ids)):
            track = cls.sp.track(track_ids[i])
            tracks.append(track)
        return tracks

    @classmethod
    def get_data(cls, track):
        genres = []
        name = track['name']
        artist = track['artists'][0]
        artist_info = cls.sp.artist(artist['external_urls']['spotify'])
        track_artist = artist['name']
        img_link = track['album']['images'][0]['url']
        img = Image.open(requests.get(img_link, stream=True).raw)

        # only one time use
        # img.save('{}.jpg'.format(name), "JPEG", quality=80,
        #          optimize=True, progressive=True)

        for genre in artist_info['genres']:
            genres.append(genre)

        return name, track_artist, genres, img

    # Aggregates individual tracks with their name, artist, genre and image and populates them in a list
    @classmethod
    def aggregate_data(cls, tracks):
        copy = tracks.copy()
        data = []
        names = []
        for i in range(len(tracks)):
            name, track_artist, genres, img = cls.get_data(tracks[i])

            track_dict = {
                'name': name,
                'artist': track_artist,
                'genre': genres,
                'image': img,
            }
            data.append(track_dict)
            names.append(name)
        return data, names

    @classmethod
    def find_song(cls, track):
        name = track['name'].replace(' ', '')
        return '{}.mp3'.format(name)

    # Creates dictionary with information about the song name and data associated with the song
    @classmethod
    def create_music_dictionary(cls, data, names):
        search_dict = {}
        for i in range(len(data)):
            name = names[i].replace(' ', '')
            name = name.replace('&', '')
            name = name.replace('.', '')
            search_dict[name] = data[i]
        return search_dict


music = Music()
tracks = music.populate_tracks()
data, names = music.aggregate_data(tracks)
final_dict = music.create_music_dictionary(data, names)
print(names)